Previously the provider created a fresh Cursor agent every turn and
re-sent the whole transcript: robust but cache-hostile, increasingly
costly as a conversation grows, and it paid opencode's system prompt on
top of Cursor's own. Opt-in `session: true` resumed one agent per session
but blindly: it could drift from opencode's view of history (message
edits, reverts, opencode-side compaction) and was polluted by non-chat
side calls (e.g. title generation).

Add `session: "auto"` (new default) which hashes only the parts opencode
replays verbatim — the system prompt and the user-message sequence — and
classifies each turn:

- new          -> fresh agent, full transcript, pool it
- side-call    -> system prompt differs; fresh ephemeral agent, pool untouched
- continuation -> prior user seq is an exact prefix + exactly one new user
                  message; resume the pooled agent, send only the new message
- divergence   -> edit/revert/compaction/queued msgs (or failed resume);
                  fresh agent + full transcript, re-pool

Worst case on any misclassification is one self-healing full replay —
never worse than the old default. `session: true` is now an alias for
"auto"; `session: false` keeps the always-fresh behavior.

Also include tool outputs (truncated: 2000 chars/result, 500/args) in the
flattened transcript so fresh/divergence/`session: false` replays stay
faithful instead of dropping prior tool results to `[result of X]`
placeholders.

OPENCODE_CURSOR_DEBUG=1 logs per-turn classification and cache usage.
Adds transcript-fingerprint unit tests, rewrites session-pool tests for
the decision-driven acquireAgent contract, and adds a live
session-reuse smoke script.

The config hook only snapshots opencode's MCP set once at startup, so
mid-session enable/disable never reached the Cursor agent. Re-forward the
live set from chat.params using client.mcp.status() (runtime truth) +
client.config.get() (launch specs), and force a fresh Agent.create when the
forwarded set changes between turns (a resumed agent keeps its original
servers).

Map remote OAuth client registration (clientId/clientSecret/scope) onto the
Cursor SDK's auth block so the agent runs its own OAuth flow. opencode's
access token never lands in config.mcp, so servers needing OAuth without a
shareable clientId (dynamic registration / needs_auth) are skipped and the
user is notified via a one-time toast instead of forwarding a spec that 401s.

The pool was in-memory only: an opencode restart lost the fingerprint
records, so the first turn of every resumed conversation classified as
"new" and paid a cache-cold full-transcript replay even though the
Cursor agent (and its conversation, in Cursor's checkpoint store) was
still resumable.

Persist the records best-effort to
~/.cache/opencode-cursor/session-pool.json following the model-cache
pattern (never throws, optimization-only). Records carry updatedAt and
are pruned to a 7-day TTL and a 200-entry most-recently-used cap. The
in-memory pool lazily hydrates from disk (memory wins on conflict);
concurrent opencode processes are last-write-wins on the whole file,
where a lost record costs exactly one self-healing full replay.

clearAgentPool() now wipes the disk store too; a new
resetSessionPoolMemory() test hook simulates process restarts.